// pages/buyticket/buyticket.js
import { getProductList, getProductTypes } from '../../api/product'
import { getTProductList, getHotTProducts } from '../../api/tproduct'

Page({
  data: {
    titleList: [], // 商品类型列表
    currentCate: 0,
    navScrollTop: 0,
    sectionTops: [],
    scroll: 0,
    productList: [], // 商品列表
    hotPackages: [], // 热门套餐列表
    packageList: [], // 套餐列表
    searchValue: '', // 搜索关键词
    loading: false, // 加载状态
    pageSize: 20,
    pageNum: 1,
    hasMore: true, // 是否还有更多数据
    isPackageType: false // 是否是套餐类型
  },

  // 切换分类
  async switchCategory(e) {
    if (this.data.loading) return
    
    const index = e.currentTarget.dataset.index
    const type = e.currentTarget.dataset.type || ''
    const currentType = this.data.titleList[index]
    
    if (!currentType) return

    // 如果正在搜索，先清空搜索
    if (this.data.searchValue) {
      this.setData({ searchValue: '' })
    }
    
    // 判断是否是套餐类型（包含"套餐"字样）
    const isPackageType = type.includes('套餐')
    
    this.setData({
      currentCate: index,
      productList: [], // 清空商品列表
      packageList: [], // 清空套餐列表
      pageNum: 1,
      hasMore: true,
      isPackageType
    })

    // 根据类型加载不同数据
    try {
      if (isPackageType) {
        await this.loadPackages(currentType.productTypeId)
      } else {
        await this.loadProducts(currentType.productTypeId)
      }
    } catch (error) {
      console.error('切换分类失败:', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    }
  },

  // 内容滚动事件
  onContentScroll(e) {
    if (!e || !e.detail) return
    const scrollTop = e.detail.scrollTop
    this.setData({
      scroll: scrollTop
    })
  },

  // 搜索输入变化（包括删除操作、不同事件明细结构）
  onSearchInput(e) {
    if (!e || e.detail === undefined || e.detail === null) return
    
    // 兼容 event.detail 可能为字符串或对象({ value }) 的情况
    const detail = e.detail
    const value = typeof detail === 'object' && detail !== null && Object.prototype.hasOwnProperty.call(detail, 'value')
      ? detail.value
      : detail
    this.setData({
      searchValue: value
    })

    // 使用防抖进行搜索（删除/backspace 同样触发）
    if (this.searchTimer) {
      clearTimeout(this.searchTimer)
    }
    
    // 当输入被清空时，立即恢复列表
    if (value === '') {
      this.onSearchClear()
      return
    }
    
    // 延迟搜索，避免频繁请求
    this.searchTimer = setTimeout(() => {
      this.doSearch(value)
    }, 300)
  },

  // 搜索输入变化（兼容旧版本）
  onSearch(e) {
    this.onSearchInput(e)
  },

  // 清空搜索
  onSearchClear() {
    // 取消未完成的防抖定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer)
      this.searchTimer = null
    }

    this.setData({
      searchValue: '',
      productList: [],
      packageList: [],
      pageNum: 1,
      hasMore: true,
      // 清空时恢复到普通商品视图
      isPackageType: false
    })
    
    // 重新加载当前分类数据
    const currentType = this.data.titleList[this.data.currentCate]
    this.loadProducts(currentType?.productTypeId)
  },

  // 搜索确认
  onSearchConfirm() {
    this.doSearch(this.data.searchValue)
  },

  // 执行搜索
  async doSearch(keyword) {
    if (!keyword) return

    this.setData({
      productList: [],
      packageList: [],
      pageNum: 1,
      hasMore: true
    })

    wx.showLoading({
      title: '搜索中...',
      mask: true
    })

    try {
      // 同时搜索商品和套餐
      const [productsRes, packagesRes] = await Promise.all([
        getProductList({
          pageNum: 1,
          pageSize: this.data.pageSize,
          keyword
        }),
        getTProductList({
          pageNum: 1,
          pageSize: this.data.pageSize,
          keyword
        })
      ])

      const products = Array.isArray(productsRes.data) ? productsRes.data : 
                      (productsRes.data && Array.isArray(productsRes.data.records) ? productsRes.data.records : [])
      const packages = Array.isArray(packagesRes.data) ? packagesRes.data : 
                      (packagesRes.data && Array.isArray(packagesRes.data.records) ? packagesRes.data.records : [])
      this.setData({
        productList: products,
        packageList: packages,
        isPackageType: packages.length > 0 && products.length === 0, // 如果只有套餐结果，切换到套餐视图
        hasMore: false // 搜索结果不支持加载更多
      })
    } catch (error) {
      console.error('搜索失败:', error)
      wx.showToast({
        title: '搜索失败，请重试',
        icon: 'none'
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 加载商品数据
  async loadProducts(typeId = null) {
    if (!this.data.hasMore || this.data.loading) return

    this.setData({ loading: true })
    try {
      const { pageNum, pageSize, searchValue } = this.data
      const params = {
        pageNum,
        pageSize,
        keyword: searchValue || undefined
      }

      // 只有当typeId是有效的数字时才添加到参数中
      if (typeId && !isNaN(parseInt(typeId))) {
        params.productTypeId = parseInt(typeId)
      }

      const res = await getProductList(params)
      const list = Array.isArray(res.data) ? res.data : 
                  (res.data && Array.isArray(res.data.records) ? res.data.records : [])
      const total = res.total || (res.data && res.data.total) || 0

      if (Array.isArray(list)) {
        // 追加新数据到列表
        this.setData({
          productList: [...this.data.productList, ...list],
          hasMore: this.data.productList.length + list.length < total,
          pageNum: list.length > 0 ? this.data.pageNum + 1 : this.data.pageNum
        })
      }
    } catch (error) {
      console.error('加载商品失败:', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    } finally {
      this.setData({ loading: false })
    }
  },

  // 加载套餐数据
  async loadPackages(packageType = null) {
    if (!this.data.hasMore || this.data.loading) return

    this.setData({ loading: true })
    try {
      const { pageNum, pageSize, searchValue } = this.data
      const params = {
        pageNum,
        pageSize,
        packageType: packageType && !isNaN(parseInt(packageType)) ? parseInt(packageType) : undefined,
        keyword: searchValue || undefined
      }

      const res = await getTProductList(params)
      const list = Array.isArray(res.data) ? res.data : 
                  (res.data && Array.isArray(res.data.records) ? res.data.records : [])
      const total = res.total || (res.data && res.data.total) || 0

      if (Array.isArray(list)) {
        // 追加新数据到列表
        this.setData({
          packageList: [...this.data.packageList, ...list],
          hasMore: this.data.packageList.length + list.length < total,
          pageNum: list.length > 0 ? this.data.pageNum + 1 : this.data.pageNum
        })
      }
    } catch (error) {
      console.error('加载套餐失败:', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    } finally {
      this.setData({ loading: false })
    }
  },

  // 加载热门套餐
  async loadHotPackages() {
    try {
      const res = await getHotTProducts(1, 5) // 只加载前5个热门套餐
      const packages = Array.isArray(res.data) ? res.data : 
                      (res.data && Array.isArray(res.data.records) ? res.data.records : [])
      
      this.setData({
        hotPackages: packages
      })
    } catch (error) {
      console.error('加载热门套餐失败:', error)
    }
  },

  // 加载商品类型
  async loadProductTypes() {
    try {
      const res = await getProductTypes()
      const types = Array.isArray(res.data) ? res.data : []
      
      if (Array.isArray(types)) {
        this.setData({
          titleList: types
        })

        // 加载默认分类的数据
        await this.loadProducts()
      }
    } catch (error) {
      console.error('加载商品类型失败:', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    }
  },

  // 查看更多套餐
  viewMorePackages() {
    wx.navigateTo({
      url: '/pages/packages/packages'
    })
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    Promise.all([
      this.loadProductTypes(),
      this.loadHotPackages(),
      // this.calcSectionPositions()
    ])

    this.setData({
      currentCate: options.currentCate
    })
  },


  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    // 搜索状态下不支持加载更多
    if (this.data.searchValue) return

    const currentType = this.data.titleList[this.data.currentCate]
    if (!currentType) return

    if (this.data.isPackageType) {
      this.loadPackages(currentType.productTypeId)
    } else {
      this.loadProducts(currentType.productTypeId)
    }
  },

  // 跳转到商品详情
  goToDetail(e) {
    if (!e || !e.currentTarget || !e.currentTarget.dataset) return
    const { id } = e.currentTarget.dataset
    if (!id) return

    wx.navigateTo({
      url: `/pages/scenicdetails/scenicdetails?id=${id}&type=0`
    })
  },

  // 跳转到套餐详情
  goToPackageDetail(e) {

    if (!e || !e.currentTarget || !e.currentTarget.dataset) return
    const { id } = e.currentTarget.dataset
    if (!id) return

    wx.navigateTo({
      url: `/pages/scenicdetails/scenicdetails?id=${id}&type=1`
    })
  }
})